
import { isArray } from './index';
// 获取配置的数据项，主要将非数字处理成数字
const getSeriesItem = (seriesStr: any) => {
  if (!seriesStr) {
    return 0;
  }
  const numArray = String(seriesStr).match(/-?\d+(.\d+)?/g);
  if (!numArray) {
    return 0;
  }
  if (isNaN(Number(numArray[0]))) {
    return 0;
  }
  return Number(numArray[0]);
};

// 校验是否满足该条件
const checkCondition = (conditionDependencyMap, currentData, condition, type) => {
  if (!condition || !condition.conditionType) {
    return false;
  }
  const { conditionType, conditionValue } = condition;
  let currentConditionValue = conditionDependencyMap.value[`_${conditionValue.id}`]();

  // 如果条件值不存在，则不满足条件
  if (
      currentConditionValue === undefined ||
      currentConditionValue === null ||
      currentData === undefined ||
      currentData === null
  ) {
    return false;
  }
  // 如果是number类型,传入的值无法转为数字
  if (type === 'NUMBER' && isNaN(Number(currentConditionValue))) {
    return false;
  }

  switch (conditionType) {
    case 'contain': // 包含
      return String(currentData).indexOf(currentConditionValue) > -1;
    case 'notContain': // 不包含
      return String(currentData).indexOf(currentConditionValue) === -1;
    case 'empty': // 为空
      return !currentData;
    case 'notEmpty': // 非空
      return !!currentData;
    case 'startWith': // 开头是
      return String(currentData).startsWith(currentConditionValue);
    case 'notStartWith': // 开头不是
      return !String(currentData).startsWith(currentConditionValue);
    case 'endWith': // 结尾是
      return String(currentData).endsWith(currentConditionValue);
    case 'notEndWith': // 结尾不是
      return !String(currentData).endsWith(currentConditionValue);
    case 'GT': // 大于
      return currentData > getSeriesItem(currentConditionValue);
    case 'LT': // 小于
      return currentData < getSeriesItem(currentConditionValue);
    case 'EQ': // 等于
      return currentData === getSeriesItem(currentConditionValue);
    case 'NE': // 不等于
      return currentData !== getSeriesItem(currentConditionValue);
    case 'GE': // 大于等于
      return currentData >= getSeriesItem(currentConditionValue);
    case 'LE': // 小于等于
      return currentData <= getSeriesItem(currentConditionValue);
    default:
      return false;
  }
};

// PC端图表所需数据格式
interface dataSetsType {
  seriesData: dataSetsSeriesDataItemType[]; // 数据
  source?: Array<Record<string, any>>; // 数据源
  xAxisData?: Array<Record<string, any>>; // x轴数据
  yAxisData?: Array<Record<string, any>>; // y轴数据
  indicatorData?: Array<Record<string, any>>; // 雷达数据
  min?: number | null; // 仪表盘最小值
  max?: number | null; // 仪表盘最大值
}
interface dataSetsSeriesDataItemType {
  name?: string;
  data: any;
}

// PC端图表数据源转换
export const getPagePcChartsDataSourceConvert = (
  conditionDependencyMap,
  type,
  list,
  convert,
  conditionConfig,
  isConversion,
  isStatic,
  propsDefined,
) => {
  // 将条件格式转换成key的map
  const conditionConfigMap = {};
  if (conditionConfig) {
    conditionConfig.forEach((item) => {
      if (conditionConfigMap.hasOwnProperty(item.fieldKey)) {
        conditionConfigMap[item.fieldKey].push(item);
      } else {
        conditionConfigMap[item.fieldKey] = [item];
      }
    });
  }
  switch (type) {
    case 'bar':
      return PagePcLineAndBarChartDataSourceConvert(
        conditionDependencyMap,
        list,
        convert,
        conditionConfigMap,
        isConversion,
        isStatic,
        type,
      );
    case 'line':
      return PagePcLineAndBarChartDataSourceConvert(
        conditionDependencyMap,
        list,
        convert,
        conditionConfigMap,
        isConversion,
        isStatic,
        type,
      );
    case 'radar':
      return PagePcRadarChartDataSourceConvert(
        conditionDependencyMap,
        list,
        convert,
        conditionConfigMap,
        isConversion,
        isStatic,
        type,
        propsDefined,
      );
    case 'gauge':
      return PagePcGaugeChartDataSourceConvert(
        conditionDependencyMap,
        list,
        convert,
        conditionConfigMap,
        isConversion,
        isStatic,
        type,
        propsDefined,
      );
    case 'pie':
      return PagePcPieChartDataSourceConvert(
        conditionDependencyMap,
        list,
        convert,
        conditionConfigMap,
        isConversion,
        isStatic,
      );
  }
};
/**
 * 折线和柱状图数据处理
 * @param conditionDependencyMap  条件配置依赖集合
 * @param list  静态数据或者动态数据
 * @param convert 转换对应的配置数据
 * @param conditionConfigMap  条件配置对应的数据
 * @param isConversion 是否开启转换
 * @param isStatic 是否是静态数据
 * @param chartType 图表类型
 * @returns dataSets
 */
export const PagePcLineAndBarChartDataSourceConvert = (
  conditionDependencyMap,
  list,
  convert,
  conditionConfigMap,
  isConversion,
  isStatic,
  chartType,
) => {
  // 设置基础值
  const dataSets: dataSetsType = {
    seriesData: [],
    xAxisData: [],
  };
  // 如果传入值不可转换，返回
  if (!list || !isArray(list) || list.length === 0) {
    return dataSets;
  }
  // 遍历数据，开启数据转化的处理
  if (isConversion && convert) {
    list.forEach((item) => {
      // 仅在有类别时才进行转换，如果没有，省略该数据
      if (item[convert.categories]) {
        dataSets.xAxisData && dataSets.xAxisData.push(item[convert.categories]);
        let categoriesStyle = '';
        conditionConfigMap[convert.categories] &&
          conditionConfigMap[convert.categories].forEach((configItem) => {
            if (
              checkCondition(
                conditionDependencyMap,
                item[convert.categories],
                configItem.condition,
                configItem.type,
              )
            ) {
              categoriesStyle = configItem.style;
            }
          });
        if (convert.series && convert.series.length > 0) {
          convert.series.forEach((seriesItem, index) => {
            const seriesItemData = item[seriesItem.key];
            let style = '';
            conditionConfigMap[seriesItem.key] &&
              conditionConfigMap[seriesItem.key].forEach((configItem) => {
                if (
                  checkCondition(
                    conditionDependencyMap,
                    seriesItemData,
                    configItem.condition,
                    configItem.type,
                  )
                ) {
                  style = configItem.style;
                }
              });
            // 判断是否有样式，series优先级高于categories
            style = style ? style : categoriesStyle ? categoriesStyle : '';
            if (dataSets.seriesData[index]) {
              dataSets.seriesData[index].data.push(
                style
                  ? chartType === 'line'
                    ? {
                        value: seriesItemData,
                        itemStyle: {
                          color: style,
                        },
                        label: {
                          color: style,
                        },
                      }
                    : {
                        value: seriesItemData,
                        itemStyle: {
                          color: style,
                        },
                      }
                  : seriesItemData,
              );
            } else {
              // 不存在初始化配置
              dataSets.seriesData[index] = {
                name: seriesItem.legend,
                data: [
                  style
                  ? chartType === 'line'
                    ? {
                        value: seriesItemData,
                        itemStyle: {
                          color: style,
                        },
                        label: {
                          color: style,
                        },
                      }
                    : {
                        value: seriesItemData,
                        itemStyle: {
                          color: style,
                        },
                      }
                  : seriesItemData,
                ],
              };
            }
          });
        }
      }
    });
  } else if (isStatic && !isConversion) {
    // 静态数据并且没有开启数据源转化
    const x = 'x';
    const y = 'y';
    const name = 'name';
    const seriesData = {};
    list.forEach((item) => {
      if (!(dataSets.xAxisData && dataSets.xAxisData.includes(item[x]))) {
        dataSets.xAxisData && dataSets.xAxisData.push(item[x]);
      }
      const key = item[name];
      if (seriesData[key]) {
        seriesData[key].push(item[y]);
      } else {
        seriesData[key] = [item[y]];
      }
    });
    dataSets.seriesData = Object.keys(seriesData).map((key) => {
      return {
        name: key,
        data: seriesData[key],
      };
    });
  }
  return dataSets;
};

/**
 * 饼图数据处理
 * @param conditionDependencyMap  条件配置依赖集合
 * @param list  静态数据或者动态数据
 * @param convert 转换对应的配置数据
 * @param conditionConfigMap  条件配置对应的数据
 * @param isConversion 是否开启转换
 * @param isStatic 是否是静态数据
 * @returns dataSets
 */
export const PagePcPieChartDataSourceConvert = (
  conditionDependencyMap,
  list,
  convert,
  conditionConfigMap,
  isConversion,
  isStatic,
) => {
  // 设置基础值
  const dataSets = {
    seriesData: [
      {
        data: [],
      },
    ],
  };
  // 如果传入值不可转换，返回
  if (!list || !isArray(list) || list.length === 0) {
    return dataSets;
  }
  // 遍历数据，开启数据转化的处理
  if (isConversion && convert) {
    list.forEach((item) => {
      const seriesItemData = item[convert['value']];
      let categoriesStyle = '';
      conditionConfigMap[convert.name] &&
        conditionConfigMap[convert.name].forEach((configItem) => {
          if (
            checkCondition(
              conditionDependencyMap,
              item[convert['name']],
              configItem.condition,
              configItem.type,
            )
          ) {
            categoriesStyle = configItem.style;
          }
        });
      let style = '';
      conditionConfigMap[convert['value']] &&
        conditionConfigMap[convert['value']].forEach((configItem) => {
          if (
            checkCondition(
              conditionDependencyMap,
              seriesItemData,
              configItem.condition,
              configItem.type,
            )
          ) {
            style = configItem.style;
          }
        });
      // 判断是否有样式，series优先级高于categories
      style = style ? style : categoriesStyle ? categoriesStyle : '';
      dataSets.seriesData[0].data.push({
        name: item[convert['name']],
        value: seriesItemData,
        itemStyle: style
          ? {
              color: style,
            }
          : {},
      });
    });
  } else if (isStatic && !isConversion) {
    // 静态数据并且没有开启数据源转化
    const value = 'value';
    const name = 'label';
    list.forEach((item) => {
      dataSets.seriesData[0].data.push({
        name: item[name],
        value: item[value],
      });
    });
  }
  return dataSets;
};

/**
 * 仪表盘数据处理
 * @param conditionDependencyMap  条件配置依赖集合
 * @param list  静态数据或者动态数据
 * @param convert 转换对应的配置数据
 * @param conditionConfigMap  条件配置对应的数据
 * @param isConversion 是否开启转换
 * @param isStatic 是否是静态数据
 * @param chartType 图表类型
 * @param propsDefined 所有属性配置的值
 * @returns dataSets
 */
export const PagePcGaugeChartDataSourceConvert = (
  conditionDependencyMap,
  list,
  convert,
  conditionConfigMap,
  isConversion,
  isStatic,
  _chartType,
  propsDefined,
) => {
  // 设置基础值
  const dataSets: dataSetsType = {
    seriesData: [
      {
        data: [],
      },
    ],
  };
  // 如果传入值不可转换，返回
  if (!list || !isArray(list) || list.length === 0) {
    return dataSets;
  }
  dataSets.source = list;
  // 开始转换
  const listItem = list[0] || {};
  // 最小值
  dataSets.min = propsDefined['systemGaugeMin'];
  // 最大值
  dataSets.max = propsDefined['systemGaugeMax'];
  // 遍历数据，开启数据转化的处理
  if (isConversion && convert) {
    const seriesItemData = listItem[convert['value']];
    let categoriesStyle = '';
    conditionConfigMap[convert['name']] &&
      conditionConfigMap[convert['name']].forEach((configItem) => {
        if (
          checkCondition(
            conditionDependencyMap,
            listItem[convert['name']],
            configItem.condition,
            configItem.type,
          )
        ) {
          categoriesStyle = configItem.style;
        }
      });

    let style = '';
    conditionConfigMap[convert['value']] &&
      conditionConfigMap[convert['value']].forEach((configItem) => {
        if (
          checkCondition(
            conditionDependencyMap,
            seriesItemData,
            configItem.condition,
            configItem.type,
          )
        ) {
          style = configItem.style;
        }
      });
    // 判断是否有样式，series优先级高于categories
    style = style ? style : categoriesStyle ? categoriesStyle : '';
    dataSets.seriesData[0].data.push({
      name: listItem[convert['name']],
      value: seriesItemData,
      // 仪表盘值的样式
      detail: style
        ? {
            formatter: '{value}',
            color: style,
          }
        : {
            formatter: '{value}',
          },
      // 仪表盘标题的颜色，由于泰山设置了默认值白色，更改标题的颜色
      title: {
        color: '#666666',
      },
    });
  } else if (isStatic && !isConversion) {
    // 静态数据并且没有开启数据源转化
    const value = 'value';
    const name = 'name';
    dataSets.seriesData[0].data.push({
      name: listItem[name],
      value: listItem[value],
      detail: {
        formatter: '{value}',
      },
      title: {
        color: '#666666',
      },
    });
  }
  return dataSets;
};

/**
 * 雷达图数据处理
 * @param conditionDependencyMap  条件配置依赖集合
 * @param list  静态数据或者动态数据
 * @param convert 转换对应的配置数据
 * @param conditionConfigMap  条件配置对应的数据
 * @param isConversion 是否开启转换
 * @param isStatic 是否是静态数据
 * @param chartType 图表类型
 * @param propsDefined 所有属性配置的值
 * @returns dataSets
 */
 export const PagePcRadarChartDataSourceConvert = (
  conditionDependencyMap,
  list,
  convert,
  conditionConfigMap,
  isConversion,
  isStatic,
  _chartType,
  propsDefined,
) => {
  // 设置基础值
  const dataSets = {
    seriesData: [
      {
        data: [],
      },
    ],
    indicatorData: [],
  };
  // 如果传入值不可转换，返回
  if (!list || !isArray(list) || list.length === 0) {
    return dataSets;
  }

  // 遍历数据，开启数据转化的处理
  if (isConversion && convert) {
    // 用于静态数据处理-获取展示维度
    const indicatorNameSet = new Set();

    list.forEach((item) => {
      // 仅在有类别时才进行转换，如果没有，省略该数据
      if (item[convert.categories]) {
        indicatorNameSet.add(item[convert.categories]);

        // let categoriesStyle = '';
        // conditionConfigMap[convert.categories] &&
        //   conditionConfigMap[convert.categories].forEach((configItem) => {
        //     if (
        //       checkCondition(
        //         conditionDependencyMap,
        //         item[convert.categories],
        //         configItem.condition,
        //         configItem.type,
        //       )
        //     ) {
        //       categoriesStyle = configItem.style;
        //     }
        //   });
        if (convert.series && convert.series.length > 0) {
          convert.series.forEach((seriesItem, index) => {
            const seriesItemData = item[seriesItem.key];
            // let style = '';
            // conditionConfigMap[seriesItem.key] &&
            //   conditionConfigMap[seriesItem.key].forEach((configItem) => {
            //     if (
            //       checkCondition(
            //         conditionDependencyMap,
            //         seriesItemData,
            //         configItem.condition,
            //         configItem.type,
            //       )
            //     ) {
            //       style = configItem.style;
            //     }
            //   });
            // // 判断是否有样式，series优先级高于categories
            // style = style ? style : categoriesStyle ? categoriesStyle : '';

            if (dataSets.seriesData[0].data[index]) {
              dataSets.seriesData[0].data[index].value.push(seriesItemData);
            } else {
              // 不存在初始化配置
              dataSets.seriesData[0].data[index] = {
                name: seriesItem.legend,
                value: [seriesItemData],
              };
            }
          });
        }
      }
    });
    indicatorNameSet.forEach((name) => {
      dataSets.indicatorData?.push({
        name,
        max: propsDefined['systemRadarMax'],
      });
    });
  } else if (isStatic && !isConversion) {
    // 静态数据并且没有开启数据源转化
    const resultMap = {};
    const result = [];
    // 用于静态数据处理-获取展示维度
    const dataType = list.filter((item) => item['type']);
    // 数据获取
    const newDataList = list.filter((item) => item['name']);

    for (let i = 0, len = newDataList.length; i < len; i++) {
      const name = newDataList[i].name;
      if (!resultMap[name]) {
        resultMap[name] = {
          name,
          value: [],
        };
      }
      resultMap[name].value.push(newDataList[i].value);
    }
    for (const key in resultMap) {
      const element = resultMap[key];
      element.value.length &&
        result.push({
          name: element.name,
          data: [element],
          dataFormatType: 'yAxis',
        });
    }
    // indicator格式-echarts
    const staticIndicator =
      dataType.length > 0 ? dataType.map((obj) => ({ name: obj.type, max: obj.max })) : [];

    dataSets.seriesData = result;
    dataSets.indicatorData = staticIndicator;
  }
  return dataSets;
};
